`:top
Bei der `!rekursiven Programmierung`! ruft sich eine `F33f`_`[Prozedur`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Prozedur_(Programmierung)]`_`f, `F33f`_`[Funktion`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Funktion_(Informatik)]`_`f oder `F33f`_`[Methode`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Unterprogramm]`_`f in einem `F33f`_`[Computerprogramm`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computerprogramm]`_`f selbst wieder auf (d. h. enthält eine `F33f`_`[Rekursion`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rekursion]`_`f). Auch der gegenseitige Aufruf stellt eine Rekursion dar.
Wichtig bei der `F33f`_`[rekursiven`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rekursion]`_`f `F33f`_`[Programmierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmierung]`_`f ist eine `F33f`_`[Abbruchbedingung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Abbruchbedingung]`_`f in dieser `F33f`_`[Funktion`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Funktion_(Programmierung)]`_`f, weil sich das rekursive `F33f`_`[Programm`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computerprogramm]`_`f sonst theoretisch unendlich oft selbst aufrufen würde.
Rekursive `F33f`_`[Programmierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmierung]`_`f kann unter anderem in `F33f`_`[prozeduralen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Prozedurale_Programmierung]`_`f und `F33f`_`[objektorientierten`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objektorientierte_Programmierung]`_`f `F33f`_`[Programmiersprachen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmiersprache]`_`f angewandt werden. Obwohl diese Sprachen in ihrem Sprachstandard die `F33f`_`[Rekursion`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rekursion]`_`f ausdrücklich zulassen, stellen Selbstaufrufe und gegenseitige Aufrufe hier (aufgrund der verwendeten `F33f`_`[Programmierparadigmen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmierparadigma]`_`f) jedoch eher die Ausnahme dar. Auch wenn in der Praxis zur Verbesserung des `F33f`_`[Programmierstils`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmierstil]`_`f auch hier durchaus häufig auf Rekursion zurückgegriffen wird, sind die meisten `F33f`_`[Funktionen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Funktion_(Programmierung)]`_`f in diesen Sprachen doch rein `F33f`_`[iterativ`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Iterative_Programmierung]`_`f.
In einigen Sprachen, wie z. B. in manchen `F33f`_`[funktionalen Programmiersprachen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Funktionale_Programmiersprache]`_`f oder `F33f`_`[Makroprozessoren`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Makroprozessor]`_`f, muss die rekursive Programmiermethode zwingend verwendet werden, da `F33f`_`[iterative`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Iterative_Programmierung]`_`f Sprachkonstrukte fehlen.
>>Contents
• `F0af`_`[Beispiele`#beispiele]`_`f
• `F0af`_`[Fakultät`#fakult-t]`_`f
• `F0af`_`[Binäre Suche`#bin-re-suche]`_`f
• `F0af`_`[Effizienz`#effizienz]`_`f
• `F0af`_`[Fakultät`#fakult-t]`_`f
• `F0af`_`[Implementierung`#implementierung]`_`f
• `F0af`_`[Siehe auch`#siehe-auch]`_`f
• `F0af`_`[Weblinks`#weblinks]`_`f
-─
>>Beispiele
>>>Fakultät
Ein Beispiel für die Verwendung einer `F33f`_`[rekursiven`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rekursion]`_`f `F33f`_`[Programmierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmierung]`_`f ist die Berechnung der `F33f`_`[Fakultät`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Fakultät_(Mathematik)]`_`f einer Zahl. Die Fakultät ist das `F33f`_`[Produkt`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Produkt_(Mathematik)]`_`f aller ganzen Zahlen von 1 bis zu dieser Zahl. Die Fakultät von 4 ist also 1 ⋅ ⋅ 2 ⋅ ⋅ 3 ⋅ ⋅ 4 = 24 {\\displaystyle 1\\cdot 2\\cdot 3\\cdot 4=24} .
Mathematiker definieren die Fakultät meistens so (eine rekursive Definition):
• Die Fakultät der Zahl 0 ist definitionsgemäß 1.
• Die Fakultät einer ganzen Zahl, die größer als Null ist, ist das Produkt dieser Zahl mit der Fakultät der nächstkleineren ganzen Zahl.
Die Definition funktioniert so:
Will man die `!Fakultät von 4`! berechnen, so muss man zunächst die Fakultät von 3 berechnen und das Ergebnis mit 4 multiplizieren. Will man die Fakultät von 3 berechnen, so muss man zunächst die Fakultät von 2 berechnen und das Ergebnis mit 3 multiplizieren. Will man die Fakultät von 2 berechnen, so muss man zunächst die Fakultät von 1 berechnen und das Ergebnis mit 2 multiplizieren. Will man die Fakultät von 1 berechnen, so muss man zunächst die Fakultät von 0 berechnen und das Ergebnis mit 1 multiplizieren. Die Fakultät von 0 ist nach Definition 1. Die Fakultät von 1 ist also 1*1=1 Die Fakultät von 2 ist also 1*1*2=2 Die Fakultät von 3 ist also 1*1*2*3=6 Die Fakultät von 4 ist also 1*1*2*3*4=24
In einer `F33f`_`[Programmiersprache`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmiersprache]`_`f wie Pascal, die rekursive Programmierung zulässt, kann man die `F33f`_`[Fakultät`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Fakultät_(Mathematik)]`_`f folgendermaßen eingeben:
Man definiert eine `F33f`_`[Funktion`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Funktion_(Programmierung)]`_`f `*factorial`*, die eine Zahl `*x`* als Eingabewert bekommt. Diese Funktion multipliziert `*x`* mit dem Rückgabewert von `*factorial(x - 1)`* außer bei `*x = 0`*, dann liefert die Funktion das Ergebnis 1. Dies ist die Abbruchbedingung:
`!Rekursive Implementation der Fakultätsfunktion `!
`B100`F9d9function factorial(x: Integer): Integer;`f`b
`B100`F9d9begin`f`b
`B100`F9d9 if x = 0 then`f`b
`B100`F9d9 factorial := 1`f`b
`B100`F9d9 else`f`b
`B100`F9d9 factorial := x * factorial(x - 1);`f`b
`B100`F9d9end;`f`b
Mit der Startzahl `*x = 4`* würde der `F33f`_`[Computer`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computer]`_`f rechnen:
`B100`F9d94 * (3 * (2 * (1 * factorial(0))))`f`b
heraus kommt dann das richtige Ergebnis, nämlich 24.
>>>Binäre Suche
Die `F33f`_`[binäre Suche`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Binäre_Suche]`_`f in einem vorsortierten `F33f`_`[Array`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Feld_(Datentyp)]`_`f lässt sich `F33f`_`[rekursiv`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rekursion]`_`f `F33f`_`[implementieren`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Implementierung]`_`f. Wenn das mittlere Element kleiner als das gesuchte Element ist, wird die hintere Hälfte des Arrays rekursiv durchsucht. Wenn es größer als das gesuchte Element ist, wird die vordere Hälfte des Arrays rekursiv durchsucht. Ist es gleich dem gesuchten Element, ist die Suche beendet.
Die Abbruchbedingung für die `F33f`_`[Rekursion`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rekursion]`_`f ist erfüllt, wenn das mittlere Element gleich dem gesuchten Element ist, die Suche also erfolgreich ist, oder wenn der Endindex kleiner als der Startindex ist, die Suche also erfolglos ist.
Die folgende `F33f`_`[Funktion`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Funktion_(Programmierung)]`_`f (`F33f`_`[Methode`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Methode_(Programmierung)]`_`f) für die `F33f`_`[rekursive`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rekursion]`_`f `F33f`_`[binäre Suche`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Binäre_Suche]`_`f ist in der `F33f`_`[Programmiersprache`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmiersprache]`_`f `F33f`_`[C#`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C-Sharp]`_`f:
`B100`F9d9int RekursiveBinaereSuche(int[] werte, int gesuchterWert, int startIndex, int endIndex)`f`b
`B100`F9d9{`f`b
`B100`F9d9 if (endIndex < startIndex)`f`b
`B100`F9d9 {`f`b
`B100`F9d9 // Wenn Element nicht gefunden, dann null zurückgeben`f`b
`B100`F9d9 return null;`f`b
`B100`F9d9 }`f`b
`B100`F9d9 int mittlererIndex = (startIndex + endIndex) / 2;`f`b
`B100`F9d9 if (werte[mittlererIndex] == gesuchterWert)`f`b
`B100`F9d9 {`f`b
`B100`F9d9 // Wenn Element gefunden, dann Index zurückgeben`f`b
`B100`F9d9 return mittlererIndex;`f`b
`B100`F9d9 }`f`b
`B100`F9d9 else`f`b
`B100`F9d9 {`f`b
`B100`F9d9 if (werte[mittlererIndex] < gesuchterWert)`f`b
`B100`F9d9 {`f`b
`B100`F9d9 // Rekursiver Aufruf der Funktion für die hintere Hälfte`f`b
`B100`F9d9 return RekursiveBinaereSuche(werte, gesuchterWert, mittlererIndex + 1, endIndex);`f`b
`B100`F9d9 }`f`b
`B100`F9d9 else`f`b
`B100`F9d9 {`f`b
`B100`F9d9 // Rekursiver Aufruf der Funktion für die vordere Hälfte`f`b
`B100`F9d9 return RekursiveBinaereSuche(werte, gesuchterWert, startIndex, mittlererIndex - 1);`f`b
`B100`F9d9 }`f`b
`B100`F9d9 }`f`b
`B100`F9d9}`f`b
>>Effizienz
`F33f`_`[Rekursive`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rekursion]`_`f `F33f`_`[Programme`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computerprogramm]`_`f haben in der Regel keine gute `F33f`_`[Performance`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Performance_(Informatik)]`_`f. Durch die wiederholten Funktionsaufrufe (Inkarnationen) wird immer wieder derselbe Methodeneintrittscode bearbeitet und bei jeder Inkarnation der `F33f`_`[Kontext`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Prozesskontext]`_`f gesichert, was zu zusätzlichem `F33f`_`[Programmcode`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmcode]`_`f und höherem `F33f`_`[Arbeitsspeicherverbrauch`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Arbeitsspeicher]`_`f führt. Alle rekursiven `F33f`_`[Algorithmen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Algorithmus]`_`f lassen sich jedoch auch durch `F33f`_`[iterative Programmierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Iterative_Programmierung]`_`f implementieren und umgekehrt.
>>>Fakultät
Man hätte die `F33f`_`[Fakultät`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Fakultät_(Mathematik)]`_`f auch so `F33f`_`[implementieren`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Implementierung]`_`f können:
`B100`F9d9function factorial(x: Integer): Integer;`f`b
`B100`F9d9 var i, number: Integer;`f`b
`B100`F9d9begin`f`b
`B100`F9d9 number := 1;`f`b
`B100`F9d9`f`b
`B100`F9d9 for i := 1 to x do`f`b
`B100`F9d9 number := number * i;`f`b
`B100`F9d9`f`b
`B100`F9d9 factorial := number;`f`b
`B100`F9d9end;`f`b
Hierbei gilt die Regel, dass für einfache Probleme eine `F33f`_`[iterative`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Iterative_Programmierung]`_`f Implementierung häufig effizienter ist. So sollte z. B. auch die Fakultätsfunktion der Effizienz wegen in der Praxis iterativ implementiert werden. Bei komplizierten Problemstellungen (z. B. Aufgaben mit `F33f`_`[Bäumen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Baum_(Graphentheorie)]`_`f) hingegen lohnt sich oftmals der Einsatz einer rekursiven Lösung, da für solche Probleme eine iterative Formulierung schnell sehr unübersichtlich – und ineffizient – werden kann, da im schlimmsten Fall der `F33f`_`[Stack`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Stapelspeicher]`_`f durch den iterativen `F33f`_`[Algorithmus`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Algorithmus]`_`f selbst verwaltet werden muss, was sonst der `F33f`_`[Prozessor`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Prozessor]`_`f direkt erledigt.
Nicht alle `F33f`_`[höheren Programmiersprachen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Höhere_Programmiersprache]`_`f lassen rekursive Aufrufe zu. Ein Beispiel dazu ist älteres `F33f`_`[Fortran`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Fortran]`_`f. Ab Fortran 90 sind rekursive Aufrufe möglich. Andere `F33f`_`[Programmiersprachen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmiersprache]`_`f sind dagegen grundsätzlich rekursiv (wie z. B. `F33f`_`[Prolog`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Prolog_(Programmiersprache)]`_`f). Solche rekursiven Programmiersprachen und auch andere Sprachen wie z. B. `F33f`_`[Scheme`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Scheme]`_`f setzen die `F33f`_`[Rekursion`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rekursion]`_`f meistens effizient um.
>>Implementierung
`F33f`_`[Rekursion`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rekursion]`_`f wird in der Regel durch einen `F33f`_`[Stack`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Stapelspeicher]`_`f implementiert, der die Rücksprungadressen, aber auch alle lokalen Variablen und eventuell Funktionsergebnisse aufnimmt. Würde man, wie im obenstehenden Beispiel, die `F33f`_`[Fakultät`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Fakultät_(Mathematik)]`_`f von 4 berechnen, so würde jeder Aufruf folgende Informationen auf den Stack legen:
1. Platz für Ergebnis
2. Argument `*x`*
3. Rücksprungadresse
Zunächst würde im Hauptprogramm also `*fac(4)`* aufgerufen und damit die folgenden Informationen auf den `F33f`_`[Stack`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Stapelspeicher]`_`f gelegt:
Die Fakultätsfunktion prüft jetzt, ob das Argument 0 ist. Da dies nicht der Fall ist, wird `*4*fac(3)`* berechnet. Zunächst muss also `*fac`* mit dem Argument 3 aufgerufen werden:
Das Argument ist wieder ungleich 0, also geht’s weiter mit `*3*fac(2)`*.
Das Argument ist wieder ungleich 0, also`*2*fac(1)`*.
Das Argument ist wieder ungleich 0, also`*1*fac(0)`*.
Jetzt ist das Argument 0, das Ergebnis also 1. Wir holen die Rücksprungadresse und das Argument vom `F33f`_`[Stack`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Stapelspeicher]`_`f und schreiben die 1 in den dafür vorgesehenen Platz. Der `F33f`_`[Rücksprung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rücksprung]`_`f führt in die Fakultätsfunktion zurück:
Jetzt kann man das Ergebnis mit dem Argument multiplizieren (1*1). Das neue Ergebnis ist wieder 1. Die `F33f`_`[Rücksprungadresse`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rücksprungadresse]`_`f und das Argument werden vom `F33f`_`[Stack`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Stapelspeicher]`_`f geholt und das neue Ergebnis in den dafür vorgesehenen Platz geschrieben. `F33f`_`[Rücksprung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rücksprung]`_`f in die Fakultätsfunktion:
Wiederum wird das Ergebnis mit dem Argument multipliziert (1*2). Zurück in die Fakultätsfunktion:
Das Ergebnis wird mit dem Argument multipliziert (2*3). Zurück in die Fakultätsfunktion:
Das Ergebnis wird mit dem Argument multipliziert (6*4). Zurück ins Hauptprogramm
Das Hauptprogramm muss dann nur noch das Ergebnis `*24`* vom `F33f`_`[Stack`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Stapelspeicher]`_`f holen.
>>Siehe auch
• `F33f`_`[Quicksort`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Quicksort]`_`f
• `F33f`_`[Endrekursion`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Endrekursion]`_`f
• `F33f`_`[Programmierparadigma`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmierparadigma]`_`f
• `F33f`_`[Entrekursivierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Entrekursivierung]`_`f
>>Weblinks
Wikibooks: Rekursive Labyrinthe
– Lern- und Lehrmaterialien
`c`F0af`_`[↑ Back to top`#top]`_`f`a